sealed trait Exp[T]                                                                                                                                                                                                                          
case class Var[T](name: String) extends Exp[T]                                                                                                                                                                                               
                                                                                                                                                                                                                                             
object Test {                                                                                                                                                                                                                                
  def env[T](x: Var[T]): T = ???                                                                                                                                                                                                             
                                                                                                                                                                                                                                             
  def eval[S](e: Exp[S]) = e match {                                                                                                                                                                                                         
    case v: Var[foo] =>                                                                                                                                                                                                                      
      env(v)                                                                                                                                                                                                                                 
  }                                                                                                                                                                                                                                          
}

==> isSubType Any <:< foo
  ==> isSubType Any <:< S
   ==> isSubType Any <:< foo

narrow gadt bound of type foo:  from below to S TypeRef(NoPrefix,type S) false
narrow gadt bound of type S:  from below to foo TypeRef(NoPrefix,type foo) false

object Test {
 
  class Foo[A]
  case class Bar[A, B](f: B => Foo[A]) extends Foo[A]

  def meth[A](consumer: A => Unit, s: Foo[A]): Unit = {
    s match {
      case bar: Bar[a, bt] => {
        meth[bt](((e: bt) => meth(consumer, new Foo[a])), new Foo[bt])
      }
    }
  }
}